namespace Jink.Protocol.Core.StatusCodes
{
    public static class EnforceStatusCode
    {
        /// <summary>Equivalent to HTTP status 100. Indicates that the client can continue with its request.</summary>
        public static StatusCodeException Continue()
        {
            return new StatusCodeException(StatusCode.Continue);
        }
        
        /// <summary>Equivalent to HTTP status 101. Indicates that the protocol version or protocol is being changed.</summary>
        public static StatusCodeException SwitchingProtocols()
        {
            return new StatusCodeException(StatusCode.SwitchingProtocols);
        }
        
        /// <summary>Equivalent to HTTP status 200. Indicates that the request succeeded and that the requested information is in the response. This is the most common status code to receive.</summary>
        public static StatusCodeException OK()
        {
            return new StatusCodeException(StatusCode.OK);
        }
        
        /// <summary>Equivalent to HTTP status 201. Indicates that the request resulted in a new resource created before the response was sent.</summary>
        public static StatusCodeException Created()
        {
            return new StatusCodeException(StatusCode.Created);
        }
        
        /// <summary>Equivalent to HTTP status 202. Indicates that the request has been accepted for further processing.</summary>
        public static StatusCodeException Accepted()
        {
            return new StatusCodeException(StatusCode.Accepted);
        }
        
        /// <summary>Equivalent to HTTP status 203. Indicates that the returned metainformation is from a cached copy instead of the origin server and therefore may be incorrect.</summary>
        public static StatusCodeException NonAuthoritativeInformation()
        {
            return new StatusCodeException(StatusCode.NonAuthoritativeInformation);
        }
        
        /// <summary>Equivalent to HTTP status 204. Indicates that the request has been successfully processed and that the response is intentionally blank.</summary>
        public static StatusCodeException NoContent()
        {
            return new StatusCodeException(StatusCode.NoContent);
        }
        
        /// <summary>Equivalent to HTTP status 205. Indicates that the client should reset (not reload) the current resource.</summary>
        public static StatusCodeException ResetContent()
        {
            return new StatusCodeException(StatusCode.ResetContent);
        }
        
        /// <summary>Equivalent to HTTP status 206. Indicates that the response is a partial response as requested by a GET request that includes a byte range.</summary>
        public static StatusCodeException PartialContent()
        {
            return new StatusCodeException(StatusCode.PartialContent);
        }
        
        /// <summary>Equivalent to HTTP status 300. Indicates that the requested information has multiple representations. The default action is to treat this status as a redirect and follow the contents of the Location header associated with this response.</summary>
        public static StatusCodeException MultipleChoices()
        {
            return new StatusCodeException(StatusCode.MultipleChoices);
        }
        
        /// <summary>Equivalent to HTTP status 300. Indicates that the requested information has multiple representations. The default action is to treat this status as a redirect and follow the contents of the Location header associated with this response.</summary>
        public static StatusCodeException Ambiguous()
        {
            return new StatusCodeException(StatusCode.Ambiguous);
        }
        
        /// <summary>Equivalent to HTTP status 301. Indicates that the requested information has been moved to the URI specified in the Location header. The default action when this status is received is to follow the Location header associated with the response.</summary>
        public static StatusCodeException MovedPermanently()
        {
            return new StatusCodeException(StatusCode.MovedPermanently);
        }
        
        /// <summary>Equivalent to HTTP status 301. Indicates that the requested information has been moved to the URI specified in the Location header. The default action when this status is received is to follow the Location header associated with the response. When the original request method was POST, the redirected request will use the GET method.</summary>
        public static StatusCodeException Moved()
        {
            return new StatusCodeException(StatusCode.Moved);
        }
        
        /// <summary>Equivalent to HTTP status 302. Indicates that the requested information is located at the URI specified in the Location header. The default action when this status is received is to follow the Location header associated with the response. When the original request method was POST, the redirected request will use the GET method.</summary>
        public static StatusCodeException Found()
        {
            return new StatusCodeException(StatusCode.Found);
        }
        
        /// <summary>Equivalent to HTTP status 302. Indicates that the requested information is located at the URI specified in the Location header. The default action when this status is received is to follow the Location header associated with the response. When the original request method was POST, the redirected request will use the GET method.</summary>
        public static StatusCodeException Redirect()
        {
            return new StatusCodeException(StatusCode.Redirect);
        }
        
        /// <summary>Equivalent to HTTP status 303. <see cref="F:System.Net.HttpStatusCode.SeeOther"></see> automatically redirects the client to the URI specified in the Location header as the result of a POST. The request to the resource specified by the Location header will be made with a GET.</summary>
        public static StatusCodeException SeeOther()
        {
            return new StatusCodeException(StatusCode.SeeOther);
        }
        
        /// <summary>Equivalent to HTTP status 303. <see cref="F:System.Net.HttpStatusCode.RedirectMethod"></see> automatically redirects the client to the URI specified in the Location header as the result of a POST. The request to the resource specified by the Location header will be made with a GET.</summary>
        public static StatusCodeException RedirectMethod()
        {
            return new StatusCodeException(StatusCode.RedirectMethod);
        }
        
        /// <summary>Equivalent to HTTP status 304. Indicates that the client's cached copy is up to date. The contents of the resource are not transferred.</summary>
        public static StatusCodeException NotModified()
        {
            return new StatusCodeException(StatusCode.NotModified);
        }
        
        /// <summary>Equivalent to HTTP status 305. Indicates that the request should use the proxy server at the URI specified in the Location header.</summary>
        public static StatusCodeException UseProxy()
        {
            return new StatusCodeException(StatusCode.UseProxy);
        }
        
        /// <summary>Equivalent to HTTP status 306. Is a proposed extension to the HTTP/1.1 specification that is not fully specified.</summary>
        public static StatusCodeException Unused()
        {
            return new StatusCodeException(StatusCode.Unused);
        }
        
        /// <summary>Equivalent to HTTP status 307. Indicates that the request information is located at the URI specified in the Location header. The default action when this status is received is to follow the Location header associated with the response. When the original request method was POST, the redirected request will also use the POST method.</summary>
        public static StatusCodeException TemporaryRedirect()
        {
            return new StatusCodeException(StatusCode.TemporaryRedirect);
        }
        
        /// <summary>Equivalent to HTTP status 307. Indicates that the request information is located at the URI specified in the Location header. The default action when this status is received is to follow the Location header associated with the response. When the original request method was POST, the redirected request will also use the POST method.</summary>
        public static StatusCodeException RedirectKeepVerb()
        {
            return new StatusCodeException(StatusCode.RedirectKeepVerb);
        }
        
        /// <summary>Equivalent to HTTP status 400. Indicates that the request could not be understood by the server. Is sent when no other error is applicable, or if the exact error is unknown or does not have its own error code.</summary>
        public static StatusCodeException BadRequest()
        {
            return new StatusCodeException(StatusCode.BadRequest);
        }
        
        /// <summary>Equivalent to HTTP status 401. Indicates that the requested resource requires authentication. The WWW-Authenticate header contains the details of how to perform the authentication.</summary>
        public static StatusCodeException Unauthorized()
        {
            return new StatusCodeException(StatusCode.Unauthorized);
        }
        
        /// <summary>Equivalent to HTTP status 402. Is reserved for future use.</summary>
        public static StatusCodeException PaymentRequired()
        {
            return new StatusCodeException(StatusCode.PaymentRequired);
        }
        
        /// <summary>Equivalent to HTTP status 403. Indicates that the server refuses to fulfill the request.</summary>
        public static StatusCodeException Forbidden()
        {
            return new StatusCodeException(StatusCode.Forbidden);
        }
        
        /// <summary>Equivalent to HTTP status 404. Indicates that the requested resource does not exist on the server.</summary>
        public static StatusCodeException NotFound()
        {
            return new StatusCodeException(StatusCode.NotFound);
        }
        
        /// <summary>Equivalent to HTTP status 405. Indicates that the request method (POST or GET) is not allowed on the requested resource.</summary>
        public static StatusCodeException MethodNotAllowed()
        {
            return new StatusCodeException(StatusCode.MethodNotAllowed);
        }
        
        /// <summary>Equivalent to HTTP status 406. Indicates that the client has indicated with Accept headers that it will not accept any of the available representations of the resource.</summary>
        public static StatusCodeException NotAcceptable()
        {
            return new StatusCodeException(StatusCode.NotAcceptable);
        }
        
        /// <summary>Equivalent to HTTP status 407. Indicates that the requested proxy requires authentication. The Proxy-authenticate header contains the details of how to perform the authentication.</summary>
        public static StatusCodeException ProxyAuthenticationRequired()
        {
            return new StatusCodeException(StatusCode.ProxyAuthenticationRequired);
        }
        
        /// <summary>Equivalent to HTTP status 408. Indicates that the client did not send a request within the time the server was expecting the request.</summary>
        public static StatusCodeException RequestTimeout()
        {
            return new StatusCodeException(StatusCode.RequestTimeout);
        }
        
        /// <summary>Equivalent to HTTP status 409. Indicates that the request could not be carried out because of a conflict on the server.</summary>
        public static StatusCodeException Conflict()
        {
            return new StatusCodeException(StatusCode.Conflict);
        }
        
        /// <summary>Equivalent to HTTP status 410. Indicates that the requested resource is no longer available.</summary>
        public static StatusCodeException Gone()
        {
            return new StatusCodeException(StatusCode.Gone);
        }
        
        /// <summary>Equivalent to HTTP status 411. Indicates that the required Content-length header is missing.</summary>
        public static StatusCodeException LengthRequired()
        {
            return new StatusCodeException(StatusCode.LengthRequired);
        }
        
        /// <summary>Equivalent to HTTP status 412. Indicates that a condition set for this request failed, and the request cannot be carried out. Conditions are set with conditional request headers like If-Match, If-None-Match, or If-Unmodified-Since.</summary>
        public static StatusCodeException PreconditionFailed()
        {
            return new StatusCodeException(StatusCode.PreconditionFailed);
        }
        
        /// <summary>Equivalent to HTTP status 413. Indicates that the request is too large for the server to process.</summary>
        public static StatusCodeException RequestEntityTooLarge()
        {
            return new StatusCodeException(StatusCode.RequestEntityTooLarge);
        }
        
        /// <summary>Equivalent to HTTP status 414. Indicates that the URI is too long.</summary>
        public static StatusCodeException RequestUriTooLong()
        {
            return new StatusCodeException(StatusCode.RequestUriTooLong);
        }
        
        /// <summary>Equivalent to HTTP status 415. Indicates that the request is an unsupported type.</summary>
        public static StatusCodeException UnsupportedMediaType()
        {
            return new StatusCodeException(StatusCode.UnsupportedMediaType);
        }
        
        /// <summary>Equivalent to HTTP status 416. Indicates that the range of data requested from the resource cannot be returned, either because the beginning of the range is before the beginning of the resource, or the end of the range is after the end of the resource.</summary>
        public static StatusCodeException RequestedRangeNotSatisfiable()
        {
            return new StatusCodeException(StatusCode.RequestedRangeNotSatisfiable);
        }
        
        /// <summary>Equivalent to HTTP status 417. Indicates that an expectation given in an Expect header could not be met by the server.</summary>
        public static StatusCodeException ExpectationFailed()
        {
            return new StatusCodeException(StatusCode.ExpectationFailed);
        }
        
        /// <summary>Equivalent to HTTP status 500. Indicates that a generic error has occurred on the server.</summary>
        public static StatusCodeException InternalServerError()
        {
            return new StatusCodeException(StatusCode.InternalServerError);
        }
        
        /// <summary>Equivalent to HTTP status 501. Indicates that the server does not support the requested function.</summary>
        public static StatusCodeException NotImplemented()
        {
            return new StatusCodeException(StatusCode.NotImplemented);
        }
        
        /// <summary>Equivalent to HTTP status 502. Indicates that an intermediate proxy server received a bad response from another proxy or the origin server.</summary>
        public static StatusCodeException BadGateway()
        {
            return new StatusCodeException(StatusCode.BadGateway);
        }
        
        /// <summary>Equivalent to HTTP status 503. Indicates that the server is temporarily unavailable, usually due to high load or maintenance.</summary>
        public static StatusCodeException ServiceUnavailable()
        {
            return new StatusCodeException(StatusCode.ServiceUnavailable);
        }
        
        /// <summary>Equivalent to HTTP status 504. Indicates that an intermediate proxy server timed out while waiting for a response from another proxy or the origin server.</summary>
        public static StatusCodeException GatewayTimeout()
        {
            return new StatusCodeException(StatusCode.GatewayTimeout);
        }
        
        /// <summary>Equivalent to HTTP status 505. Indicates that the requested HTTP version is not supported by the server.</summary>
        public static StatusCodeException HttpVersionNotSupported()
        {
            return new StatusCodeException(StatusCode.HttpVersionNotSupported);
        }
    }
}
